home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / scvs / scvs.new < prev    next >
Encoding:
Text File  |  1991-11-02  |  53.2 KB  |  2,365 lines
  1. #! /sprite/cmds/perl 
  2. #
  3. #   Scvs is the "Sprite Concurrent Version System", pronounced "skivies".
  4. #   It is a Perl script wrapper for cvs.  See the cvs man page for more
  5. #   details.
  6. #
  7. # $Header: /sprite/src/cmds/scvs/RCS/scvs,v 1.13 91/10/31 13:08:52 jhh Exp Locker: jhh $ SPRITE (Berkeley)
  8. #
  9. # Copyright 1991 Regents of the University of California
  10. # Permission to use, copy, modify, and distribute this
  11. # software and its documentation for any purpose and without
  12. # fee is hereby granted, provided that this copyright
  13. # notice appears in all copies.  The University of California
  14. # makes no representations about the suitability of this
  15. # software for any purpose.  It is provided "as is" without
  16. # express or implied warranty.
  17. #
  18.  
  19. require "option.pl";
  20. require "pwd.pl";
  21. require "ctime.pl";
  22. require "stat.pl";
  23.  
  24. $recurse = 1;
  25. $verbose = 0;
  26. $linkFile = "links";
  27. $debug = 0;
  28. $configFile = "SCVS.config";
  29. $argFile = "args";
  30. $modNameFile = "moduleName";
  31. $userFile = "SCVS/users";
  32.  
  33. @options = (
  34.     $OPT_NIL, $OPT_DOC, $OPT_NIL, 
  35.     "Usage: scvs [scvs options] command [command options]",
  36.     "V", $OPT_TRUE, *verbose, "Verbose",
  37.     "D", $OPT_TRUE, *debug, "Debug",
  38.     "r", $OPT_FUNC, "CvsOpt1", "Check out files read-only",
  39.     "w", $OPT_FUNC, "CvsOpt1", "Check out files read-write (default)",
  40.     "v", $OPT_FUNC, "CvsOpt1", "Print cvs version info",
  41.     "d", $OPT_STRING, *cvsroot, "Specify cvs root directory",
  42.     "e", $OPT_FUNC, "CvsOpt1", "Specify editor to use",
  43.     "H", $OPT_FUNC, "CvsOpt1", "Print help information",
  44. );
  45. undef($cvsargs);
  46. &Opt_Parse(*ARGV, @options, $OPT_OPTIONS_FIRST);
  47. if ($debug) {
  48.     $verbose = 1;
  49. }
  50. $cvsCmdArgs = $cvsargs;
  51.  
  52. @cvsCmds = ("join", "patch", "tag");
  53.  
  54. #
  55. # Global variables.
  56. #
  57. #    %moduleToRepos  maps module name to its relative path within the
  58. #            repository
  59. #    %reposToModule    reverse mapping of moduleToRepos
  60. #    %cwdToMod    maps current working directory to module name
  61. #    %cwdToRoot    maps current working directory within a module copy
  62. #            to the root dir of the module copy
  63. #
  64.  
  65. #
  66. # Config
  67. #
  68. # Find the configuration file and set up various configuration variables.
  69. #
  70. # Results: 0 if successful, 1 otherwise
  71. # 
  72. # Side effects: Some variables are set.
  73. #
  74.  
  75. sub Config {
  76.     local($pwd) = $ENV{'PWD'};
  77.     local($stat, $lastStat) = (0, 0);
  78.     local($tmp);
  79.     local(@attempts);
  80.  
  81.     #
  82.     # Work our way up the directory tree looking for the config file.
  83.     #
  84.     while(! -e $configFile) {
  85.     push(@attempts, $ENV{'PWD'});
  86.     &Chdir("..") == 0 || return 1;
  87.     &Stat(".");
  88.     $stat = $st_dev . $st_ino . $st_serverID;
  89.     last if ($stat eq $lastStat);
  90.     $lastStat = $stat;
  91.     }
  92.     if (! -e $configFile) {
  93.     printf("Couldn't find configuration file\n");
  94.     foreach $tmp (@attempts) {
  95.         printf("Not in $tmp\n");
  96.     }
  97.     return 1;
  98.     }
  99.     open(CONFIG, "$configFile") || die("Can't open $configFile: $!\n");
  100.     while(<CONFIG>) {
  101.     next if (/^\s*#/);
  102.     if (/^cvsroot:\s+(\S+)\s*$/) {
  103.         if (!defined($cvsroot)) {
  104.         $cvsroot = $1;
  105.         }
  106.     } elsif(/^installdir:\s+(\S+)\s*$/) {
  107.         $installdir = $1;
  108.     }
  109.     }
  110.     close(CONFIG);
  111.     if (!defined($cvsroot)) {
  112.     printf("cvsroot not set in config file\n");
  113.     return 1;
  114.     }
  115.     &Chdir("$pwd") == 0 || return 1;
  116.     return 0;
  117. }
  118.  
  119. #
  120. # PackCmd($command, @dirs)
  121. #
  122. # Runs a Pack or Unpack command on each of the directories in the list.
  123. #
  124. # Results: 0 if successful, 1 otherwise
  125. #
  126. # Side effects:  The link file is modified.
  127. #
  128.  
  129. sub PackCmd {
  130.     local($command) = shift;
  131.     local(@dirs) = @_;
  132.     local($status) = 0;
  133.     local($pwd) = $ENV{'PWD'};
  134.  
  135.     if ($#dirs < $[) {
  136.     push(@dirs, '.');
  137.     }
  138.     foreach $dir (@dirs) {
  139.     &Chdir($dir) == 0 || return 1; 
  140.     if ($command eq "pack") {
  141.         $status = &Pack($dir);
  142.     } else {
  143.         $status = &Unpack($dir);
  144.     }
  145.     if ($status) {
  146.         return $status;
  147.     }
  148.     &Chdir($pwd) == 0 || return 1; 
  149.     }
  150. }
  151. #
  152. # Pack($path)
  153. #
  154. # Finds all symbolic links in the current directory and puts them in the
  155. # link file.  The links are stored in alphabetical
  156. # order.  If $recurse is non-zero, Pack will call itself to recurse on
  157. # subdirectories.
  158. #
  159. # Results: 0 if successful, 1 otherwise
  160. #
  161. # Side effects: The link file is modified.
  162. #
  163.  
  164. sub Pack {
  165.     local($path) = shift;
  166.     local($addDir) = 0;
  167.     local($addFile) = 0;
  168.     local(%links);
  169.     local($link);
  170.  
  171.     #
  172.     # Don't pack SCVS subdirectories.
  173.     #
  174.     if ($path =~ m|.*/SCVS|) {
  175.     return 0;
  176.     }
  177.     printf(STDERR "Packing $path\n") if ($debug);
  178.     $addDir = (-d "SCVS") ? 0 : 1;
  179.     $addFile = (-f "SCVS/$linkFile") ? 0 : 1;
  180.     opendir(THISDIR, ".") || return &Error(1, "Opendir of $path failed: $!\n");
  181.     foreach $link (grep(-l, readdir(THISDIR))) {
  182.     printf(STDERR "$link\n") if ($debug);
  183.     $links{$link} = readlink($link);
  184.     }
  185.     close(THISDIR);
  186.     if (defined(%links) || (!$addFile)) {
  187.     if ($addDir) {
  188.         mkdir("SCVS", 0770) ||
  189.         return &Error(1, "Mkdir of SCVS failed: $!\n");
  190.     }
  191.     if (open(PACK, ">SCVS/$linkFile") == 0) {
  192.         printf("Can't open $linkFile: $!\n");
  193.         $status = 1;
  194.         last;
  195.     }
  196.     printf(PACK 
  197.         "# This file is used by scvs and contains symbolic link\n");
  198.     printf(PACK 
  199.         "# information.  Each line is of the form \"link target\"\n");
  200.     printf(PACK "# \$Header\n");
  201.     foreach $link (sort keys %links) {
  202.         printf(PACK "%-24s %s\n", $link, $links{$link});
  203.     }
  204.     close(PACK);
  205.     if ($addFile && (-e "CVS.adm")) {
  206.         if ($addDir) {
  207.         system("cvs -d $cvsroot add SCVS");
  208.         }
  209.         system("cvs -d $cvsroot add -m\"scvs links\" SCVS/$linkFile");
  210.     }
  211.     } 
  212.     if ($recurse) {
  213.     $status = &AllSubdirs($path, "Pack");
  214.     }
  215.     return $status;
  216. }
  217.  
  218. #
  219. # Unpack($path)
  220. #
  221. # Reads the link file in the current directory and creates symbolic links
  222. # from its contents. If recurse is non-zero, Unpack will call itself to 
  223. # recurse on subdirectories.
  224. #
  225. # Results: 0 if successful, 1 otherwise
  226. #
  227. # Side effects: Symbolic links may be created in the current directory
  228. #
  229. sub Unpack {
  230.     local($path) = shift;
  231.     local($status) = 0;
  232.  
  233.     printf(STDERR "Unpacking $path\n") if ($debug);
  234.     if (open(UNPACK, "SCVS/$linkFile")) {
  235.     while(<UNPACK>) {
  236.         next if (/^#/);
  237.         if (/(\S+)\s+(\S+)/) {
  238.         ($link, $value) = ($1, $2);
  239.         if (-l $link) {
  240.             $old = readlink($link);
  241.             if ($old ne $value) {
  242.             printf(
  243.             "Changing $link -> $value, instead of -> $old\n");
  244.             unlink($link);
  245.             } else {
  246.             next;
  247.             }
  248.         } elsif (-e $link) {
  249.             printf("File $link already exists.\n");
  250.             $status = 1;
  251.             next;
  252.         } elsif ($verbose) {
  253.             printf("Creating: $link -> $value\n");
  254.         }
  255.         if (symlink($value, $link) == 0) { 
  256.             printf("Can't create link from $link to $value: $!");
  257.             $status = 1;
  258.         }
  259.         }
  260.     }
  261.     close(UNPACK);
  262.     }
  263.     if ($recurse) {
  264.     $status = &AllSubdirs($path, "Unpack");
  265.     }
  266.     return $status;
  267. }
  268.  
  269. #
  270. # Repository(module)
  271. #
  272. # Finds the pathname of the repository directory for the given module.
  273. #
  274. # Results: The pathname
  275. #
  276. # Side effects: 
  277. #
  278.  
  279. sub Repository {
  280.     local($tmp);
  281.     $tmp = &ReadFile("$_[0]/CVS.adm/Repository", 1);
  282.     if (defined($tmp)) {
  283.     chop($tmp);
  284.     return "$cvsroot/$tmp"; 
  285.     }
  286.     return undef;
  287. }
  288.  
  289. #
  290. # Prune($path)
  291. #
  292. # Removes the given directory if it is empty (no user files or subdirectories).
  293. # Recurses on subdirectories.
  294. #
  295. # Results: 0 if successful, 1 otherwise
  296. #
  297. # Side effects: The directory or its subdirectories may be removed.
  298. #
  299.  
  300. sub Prune {
  301.     local($path) = shift;
  302.     local($i);
  303.     local($status) = 0;
  304.     local($empty) = 1;
  305.     local($tail) = substr($path, rindex($path, '/') + 1);
  306.  
  307.     if ($tail eq "SCVS") {
  308.     return 0;
  309.     }
  310.     print "Pruning $path\n" if ($debug);
  311.     $status = &AllSubdirs($path, "Prune");
  312.     if ($status) {
  313.     return $status;
  314.     }
  315.     opendir(THISDIR, ".") || 
  316.     return &Error(1, "Opendir of $path failed: $!\n"); 
  317.     @contents = grep((-f) || ((!/\./) && ($_ ne 'CVS.adm') && ($_ ne 'SCVS')));
  318.     if ($#contents >= $[
  319.     print "Found @contents in $path\n" if ($debug);
  320.     $empty = 0;
  321.     }
  322.     close(THISDIR);
  323.     if ($empty) {
  324.     print "Prune: chdir to ..\n" if ($debug);
  325.     &Chdir("..") == 0 || return 1;
  326.     print "Prune: deleting $tail\n" if ($debug);
  327.     system("rm -rf $tail");
  328.     }
  329.     return 0;
  330. }
  331.  
  332. #
  333. # CvsOpt1($optString, $nextArg)
  334. #
  335. # Appends $optString to $cvsargs.
  336. #
  337. # Results: 0 
  338. #
  339. # Side effects: None
  340. #
  341. sub CvsOpt1 {
  342.     printf("CvsOpt1 @_\n") if ($debug);
  343.     $cvsargs .= "$_[0] ";
  344.     return 0;
  345. }
  346.  
  347. #
  348. # CvsOpt2($optString, $nextArg)
  349. #
  350. # Appends $optString and $nextArg to $cvsargs.
  351. #
  352. # Results: 1
  353. #
  354. # Side effects: None
  355. #
  356. sub CvsOpt2 {
  357.     printf("CvsOpt2 @_\n") if ($debug);
  358.     $cvsargs .= "$_[0] \"$_[1]\" ";
  359.     return 1;
  360. }
  361.  
  362.  
  363. #
  364. # Checkout(@modules)
  365. #
  366. # Checks out modules.  "cvs co" is used to make a copy of the module. 
  367. # Unpack is used to unpack symbolic links.  
  368. # The current user name is added to the SCVS.users
  369. # file and a list of any other users with a copy of the module are 
  370. # printed.  Any options passed to "cvs co" are stored in the SCVS/args
  371. # file to be used on subsequent updates.
  372. #
  373. # Results: 0 if successful, 1 otherwise
  374. #
  375. # Side effects: A subdirectory is created for each module.
  376. #
  377.  
  378. sub Checkout {
  379.     local(@modules) = @_;
  380.     local($buffer, $i,$repos, $user, $date, %count, %dates);
  381.     local($found, $name);
  382.     local($prune) = 1;
  383.     local($personal) = 0;
  384.     local($args);
  385.     local(@options) = ( 
  386.     "l", $OPT_FALSE, *recurse, "Don't recurse.",
  387.     "P", $OPT_FALSE, *prune, "Don't prune empty directories.",
  388.     "i", $OPT_TRUE, *personal, "Deviation from standard source tree",
  389.     "f", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  390.     "c", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  391.     "Q", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  392.     "q", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  393.     "f", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  394.     "n", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  395.     "p", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  396.     "r", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  397.     "D", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  398.      );
  399.  
  400.     undef($cvsargs);
  401.     &Opt_Parse(*modules, @options, $OPT_OPTIONS_FIRST | $OPT_NO_SPACE);
  402.     $args = $cvsargs;
  403.  
  404.     # Put together the "cvs co" command.
  405.  
  406.     $buffer = "cvs -d $cvsroot $cvsCmdArgs co $args";
  407.  
  408.     if ($args =~ /-c/) {
  409.     system("$buffer");
  410.     return 0;
  411.     }
  412.    if (($args =~ /-r/) || ($args =~ /-D/)) {
  413.     $buffer .= "-f ";
  414.     }
  415.     $status = &Lock("r", @modules);
  416.     if ($status) {
  417.     return $status;
  418.     }
  419.     $user = getlogin;
  420.     print "@modules\n" if ($debug);
  421.  
  422. module:
  423.     foreach $i (@modules) {
  424.     local($pwd) = $ENV{'PWD'};
  425.  
  426.     printf("Checking out $i\n") if ($debug);
  427.     # Perform the "cvs co".
  428.  
  429.     printf("$buffer $i \n") if ($debug);
  430.     system("$buffer $i");
  431.  
  432.     # Store the "cvs co" arguments in the info file.
  433.  
  434.     if (! -d "$i/SCVS") {
  435.         if (!mkdir("$i/SCVS", 0770)) {
  436.         $status = &Error(1, "Mkdir of $i/SCVS failed: $!\n");
  437.         next module;
  438.         }
  439.     }
  440.     if (!open(CO, ">$i/SCVS/$argFile")) {
  441.         $status = &Error(1, "Open of $i/SCVS/$argFile failed: $!\n");
  442.         next module;
  443.     }
  444.     print(CO "# This file contains the arguments given when this\n");
  445.     print(CO "# module was checked out.\n");
  446.     print(CO "$cvsCmdArgs\n");
  447.     printf(CO "$args %s\n", $prune ? "-p" : " ");
  448.     close(CO);
  449.  
  450.     &Chdir($i) == 0 || return 1; 
  451.  
  452.     # Unpack the module.
  453.     &Unpack($i) == 0 || return &Error("Unpack of $i failed\n");
  454.  
  455.     # Prune any empty directories in the module.
  456.     if ($prune) {
  457.         &Prune($i) == 0 || return &Error(1, "Prune of $i failed\n");
  458.     }
  459.  
  460.     &Chdir($pwd) == 0 || return 1; 
  461.  
  462.     # See if any other users have a copy of the module, and add our
  463.     # own entry.
  464.  
  465.     $repos = &Repository($i);
  466.     next module if (!defined($repos));
  467.     $date = &ctime(time);
  468.     open(CO2, ">$repos/$tmpfile") ||
  469.         return &Error(1, "Open of $repos/$tmpfile failed: $!\n");
  470.     if (-e "$repos/$userFile") {
  471.         local($copy) = 0;
  472.         open(CO1, "$repos/$userFile") ||
  473.         return &Error(1, "Open of $repos/$userFile failed: $!\n");
  474.         while(<CO1>) {
  475.         $copy = 0;
  476.         next if (/^#/);
  477.         if (/^$user\s+([\w\/\.]+)\s+(.*)/) {
  478.             if ($1 eq "$pwd/$i") {
  479.             $copy = 1;
  480.             } else {
  481.             $found = 1;
  482.             push(@mine, $_);
  483.             }
  484.         } elsif (/^(\S+)\s+([\w\/\.]+)\s+(.*)/) {
  485.             $others{$1} = $3;
  486.         }
  487.         }
  488.         continue {
  489.         if (!$copy) {
  490.             print CO2 $_;
  491.         }
  492.         }
  493.         close(CO1);
  494.     } else {
  495.         printf(CO2 "# List of users with copies of this module.\n");
  496.     }
  497.     if ($#mine >= $[) {
  498.         printf("\nYou also have these copies of the $i module:\n");
  499.         print join("\n", @mine);
  500.     }
  501.     printf(CO2 "$user $pwd/$i %s", &ctime(time));
  502.     close(CO2);
  503.     if (!$personal) {
  504.         if (!rename("$repos/$tmpfile", "$repos/$userFile")) {
  505.         printf(
  506.           "Rename of $repos/$tmpfile to $repos/$userFile failed:$!\n");
  507.         unlink("$repos/$tmpfile");
  508.         next module;
  509.         }
  510.     } else {
  511.         unlink("$repos/$tmpfile");
  512.     }
  513.     if (defined(%others)) {
  514.         printf("\nThe following users have copies of the $i module:\n"); 
  515.         while(($name, $date) = each(%others)) {
  516.         printf("$name $date\n");
  517.         }
  518.     }
  519.     }
  520.     return 0;
  521. }
  522.  
  523. #
  524. # UnlockCmd(@ARGV)
  525. #
  526. # Parse arguements, then call Unlock to do the dirty work. 
  527. #
  528. # Results: 0 if successful, 1 otherwise
  529. #
  530. # Side effects: 
  531. #
  532. sub UnlockCmd {
  533.     local(@args) = @_;
  534.     local($all) = 0;
  535.     local($status) = 0;
  536.     local(@options) = (
  537.     "a", $OPT_TRUE, *all, "Remove everybody's locks",
  538.     );
  539.     &Opt_Parse(*args, @options, $OPT_OPTIONS_FIRST);
  540.     $status = &Unlock($all,@args);
  541.     return $status;
  542. }
  543.  
  544.  
  545. #
  546. # Unlock($allusers, @modules)
  547. #
  548. # Remove the locks for a list of modules.  
  549. #
  550. # Results: 0 if successful, 1 otherwise
  551. #
  552. # Side effects: 
  553. #
  554.  
  555. sub Unlock {
  556.     local($allusers) = shift;
  557.     local(@modules) = @_;
  558.     local($cvsdir, $i, $lock);
  559.     local($status) = 0;
  560.     local($user) = getlogin;
  561.  
  562.     print("Unlock $allusers @modules\n") if ($debug);
  563.     if (!defined(%moduleToRepos)) {
  564.     &ModMap;
  565.     }
  566.     if ($#modules < $[) {
  567.     push(@modules, ".");
  568.     }
  569. module:
  570.     foreach $i (@modules) {
  571.     if ($i eq ".") {
  572.         $i = &GetModuleName;
  573.         if (!defined($i)) {
  574.         $status = 1;
  575.         next module;
  576.         }
  577.     }
  578.     if (!defined($moduleToRepos{$i})) {
  579.         printf(STDERR "Module $i does not exist.\n");
  580.         $status = 1;
  581.         next module;
  582.     }
  583.     $cvsdir = "$cvsroot/$moduleToRepos{$i}/SCVS";
  584.     $lock = "$cvsdir/locks";
  585.     if (!-e $lock) {
  586.         next module;
  587.     }
  588.     if ($allusers) {
  589.         if (!unlink($lock)) {
  590.         printf("Can't remove lock file $lock: $!\n");
  591.         }
  592.         next module;
  593.     }
  594.     if (!open(UNLOCK1, "$lock")) {
  595.         print("Open of $lock failed: $!\n");
  596.         next module;
  597.     }
  598.     if (!open(UNLOCK2, ">$cvsdir/$tmpfile")) {
  599.         print("Open of $cvsdir/$tmpfile failed: $!\n");
  600.         next module;
  601.     }
  602.     flock(UNLOCK1, 2) || 
  603.         return &Error(1, "Flock(2) of $lock failed: $!\n");
  604.  
  605.     while(<UNLOCK1>) {
  606.         ($type, $name) = split(' ');
  607.         if ($name ne $user) {
  608.         print(UNLOCK2 $_);
  609.         }
  610.     }
  611.     close(UNLOCK2);
  612.     if (!rename("$cvsdir/$tmpfile", "$lock")) {
  613.         printf(
  614.           "Rename of $cvsdir/$tmpfile to $lock failed:$!\n");
  615.         unlink("$cvsdir/$tmpfile");
  616.         next module;
  617.     }
  618.     }
  619.     return $status;
  620. }
  621.  
  622. #
  623. # LockCmd(@ARGV)
  624. #
  625. # Parse any options then call Lock to do all the work.
  626. #
  627. # Results: 0 if successful, 1 otherwise
  628. #
  629. # Side effects: The lock files in the modules are updated.
  630. #
  631.  
  632. sub LockCmd {
  633.     local(@args) = @_;
  634.     local($write) = 1;
  635.     local($status) = 0;
  636.     local(@options) = (
  637.     "w", $OPT_TRUE, *write, "Write (exclusive) lock",
  638.     "r", $OPT_FALSE, *write, "Read (shared) lock",
  639.     );
  640.     print("LockCmd @args\n") if ($debug);
  641.     &Opt_Parse(*args, @options, $OPT_OPTIONS_FIRST);
  642.     $status = &Lock($write ? "w" : "r", @args);
  643.     undef(@locks);
  644.     return $status;
  645. }
  646.  
  647.  
  648. #
  649. # Lock($type, @modules)
  650. #
  651. # Make sure the modules are unlocked, and lock them.  Any modules that
  652. # we lock are put in the @lock array.  
  653. #
  654. # Results: 0 if successful, 1 otherwise
  655. #
  656. # Side effects: Lock files are created in the modules.
  657. #
  658.  
  659. sub Lock {
  660.     local($type) = shift;
  661.     local(@dirs) = @_;
  662.     local($cvsdir);
  663.     local($status) = 0;
  664.     local($i, $name);
  665.     local(@mylocks);
  666.     local($user) = getlogin;
  667.     local(@lockFiles);
  668.     local($prevType);
  669.     local($prevName);
  670.     local($prevDate);
  671.     local(@prevLocks);
  672.     local($lock);
  673.     local(@modules);
  674.  
  675.     print("Lock $type @dirs\n") if ($debug);
  676.     if ($#dirs < $[) {
  677.     @dirs = (".");
  678.     }
  679. dir:
  680.     foreach $i (@dirs) {
  681.     #
  682.     # If the directory doesn't exist then assume we've been given
  683.     # a module name instead.
  684.     #
  685.     if (! -d $i) {
  686.         $module = $i;
  687.     } else {
  688.         $module = &GetModuleName;
  689.         if (!defined($module)) {
  690.         printf("Can't find module name for dir $i\n"); 
  691.         $status = 1;
  692.         next dir;
  693.         }
  694.     }
  695.     $repos = $moduleToRepos{$module};
  696.     if (!defined($repos)) {
  697.         printf(STDERR "$i module does not exist.\n");
  698.         $status = 1;
  699.         next dir;
  700.     }
  701.     $cvsdir = "$cvsroot/$repos/SCVS";
  702.     $lock = "$cvsdir/locks";
  703.     print("Cvsdir = $cvsdir\n") if ($debug);
  704.     if (-f "$lock") {
  705.         print("Opening $lock\n") if ($debug);
  706.         open(LOCK1, "$lock") || 
  707.         return &Error(1, "Open of $lock failed: $!\n");
  708.         flock(LOCK1, 2) || 
  709.         return &Error(1, "Flock(2) of $lock failed: $!\n");
  710.         while(<LOCK1>) {
  711.         ($prevType, $prevName) = split(' ');
  712.         if ($prevName eq $user) {
  713.             if ($prevType ne $type) {
  714.             return &Error(1, "$i already locked:\n$_");
  715.             } else {
  716.             close(LOCK1);
  717.             next module;
  718.             }
  719.         } else {
  720.             if (($prevType eq "r") && ($type eq "w")) {
  721.             return &Error(1, "$i already locked:\n$_");
  722.             } elsif ($prevType eq "w") {
  723.             return &Error(1, "$i already locked:\n$_");
  724.             }
  725.         }
  726.         push(@prevLocks, $_);
  727.         }
  728.     }
  729.     open(LOCK2, ">$cvsdir/$tmpfile") ||
  730.         return &Error(1, "Open of $cvsdir/$tmpfile failed: $!\n");
  731.     foreach $i (@prevLocks) {
  732.         print(LOCK2 "$i");
  733.     }
  734.     printf(LOCK2 "$type $user %s", &ctime(time));
  735.     close(LOCK2);
  736.     if (!rename("$cvsdir/$tmpfile", "$lock")) {
  737.         printf(
  738.           "Rename of $cvsdir/$tmpfile to $lock failed:$!\n");
  739.         unlink("$cvsdir/$tmpfile");
  740.         return 1;
  741.     }
  742.     push(@mylocks, $i);
  743.     close(LOCK1);
  744.     }
  745.     if ($status) {
  746.     if (&Unlock(0, @mylocks)) {
  747.         return &Error(1, "Can't clean up in LockCmd\n");
  748.     }
  749.     }
  750.     push(@locks, @mylocks);
  751.     return $status;
  752. }
  753.  
  754. #
  755. # UpdateCmd($lock, @names)
  756. #
  757. # Update modules.  If the arguments are a list of subdirectories then
  758. # we chdir to each of them and run "cvs update".  If the arguments are
  759. # a list of files then we pass them to cvs.  If no files or directories
  760. # are specified then we update the current directory.  The arguments
  761. # for update are retrieved from the SCVS/args file.
  762. #
  763. # Results: 0 if successful, 1 otherwise
  764. #
  765. # Side effects: 
  766. #
  767.  
  768. sub UpdateCmd {
  769.     local($lock) = shift;
  770.     local(@dirs) = @_;
  771.     local(%files);
  772.     local($buffer, $i);
  773.     local($found, $name);
  774.     local($module);
  775.     local($owd);
  776.     local($tmp);
  777.     local($prune);
  778.     local($buildDirs) = 1;
  779.     local($args);
  780.     local($module);
  781.     local(@options) = ( 
  782.     "B", $OPT_FALSE, *buildDirs, "Don't create new directories.",
  783.     "l", $OPT_FALSE, *recurse, "Don't recurse on subdirs",
  784.     "Q", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  785.     "q", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  786.     "f", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  787.     "n", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  788.     "p", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  789.     "d", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  790.     "r", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  791.     "D", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  792.     );
  793.     undef($cvsargs);
  794.     &Opt_Parse(*dirs, @options, $OPT_OPTIONS_FIRST | $OPT_NO_SPACE);
  795.     $args = $cvsargs;
  796.  
  797.     print("UpdateCmd in $ENV{'PWD'}\n") if ($debug);
  798.  
  799.     # Put together the "cvs update" command.
  800.  
  801.     if ($buildDirs) {
  802.     $args .= "-d ";
  803.     }
  804.     if (! $recurse) {
  805.     $args .= "-l ";
  806.     }
  807.     $buffer = "cvs -d $cvsroot $cvsCmdArgs ";
  808.  
  809.     if ($#dirs < $[) {
  810.     push(@dirs, ".");
  811.     }
  812.     if (! -d $dirs[0]) {
  813.     $files{"."} = @dirs;
  814.     @dirs = (".");
  815.     }
  816.  
  817.     #
  818.     # Lock the modules.
  819.     #
  820.     if ($lock) {
  821.     $status = &Lock("r", @dirs); 
  822.     if ($status) {
  823.         return $status;
  824.     }
  825.     }
  826.     $owd = $ENV{'PWD'};
  827. dir: 
  828.     foreach $i (@dirs) {
  829.     $prune = 0;
  830.     &Chdir($i) == 0 || return 1; 
  831.     if (-e "SCVS/$argFile") {
  832.         local(@targs);
  833.         @targs = &ReadFile("SCVS/$argFile", 1);
  834.         print("targs = @targs\n") if ($debug);
  835.         if ($targs[1] =~ /(.*)-p(.*)/) {
  836.         $targs[1] = "$1 $2";
  837.         print("Found -p in args file\n") if ($debug);
  838.         $prune = 1;
  839.         }
  840.         chop($targs[0]);
  841.         chop($targs[1]);
  842.     }
  843.     $tmp = "$buffer $targs[0] update $args $targs[1] $files{$i}";
  844.     printf("$tmp\n") if ($debug);
  845.     system($tmp);
  846.     if (&Unpack($i)) {
  847.         printf(STDERR "Unpack of $i failed.\n");
  848.         $status = 1;
  849.     }
  850.     if ($prune) {
  851.         if (&Prune($i)) {
  852.         printf(STDERR "Prune of $i failed.\n");
  853.         $status = 1;
  854.         }
  855.     }
  856.     &Chdir($owd) == 0 || return 1; 
  857.     }
  858. }
  859. return $status;
  860.  
  861.  
  862.  
  863.  
  864.  
  865.  
  866.  
  867.  
  868.  
  869.     if ($lock) {
  870.         $status = &Lock("r","."); 
  871.         if ($status) {
  872.         return $status;
  873.         }
  874.     }
  875.     if (-e "SCVS/$argFile") {
  876.         local(@targs);
  877.         @targs = &ReadFile("SCVS/$argFile", 1);
  878.         print("targs = @targs\n") if ($debug);
  879.         if ($targs[1] =~ /(.*)-p(.*)/) {
  880.         $targs[1] = "$1 $2";
  881.         print("Found -p in args file\n") if ($debug);
  882.         $prune = 1;
  883.         }
  884.         chop($targs[0]);
  885.         chop($targs[1]);
  886.     }
  887.     $tmp = "$buffer $targs[0] update $args $targs[1] @names";
  888.     printf("$tmp\n") if ($debug);
  889.     system($tmp);
  890.     $recurse = 0;
  891.     &Unpack(".") == 0 ||
  892.         return &Error(1, "Unpack of current directory failed.\n");
  893.     } else {
  894.     #
  895.     # Lock the modules.
  896.     #
  897.     if ($lock) {
  898.         $status = &Lock("r", @names); 
  899.         if ($status) {
  900.         return $status;
  901.         }
  902.     }
  903.     $pwd = $ENV{'PWD'};
  904. module: 
  905.     foreach $i (@names) {
  906.         $prune = 0;
  907.         &Chdir($i) == 0 || return 1; 
  908.         if (-e "SCVS/$argFile") {
  909.         local(@targs);
  910.         @targs = &ReadFile("SCVS/$argFile", 1);
  911.         print("targs = @targs\n") if ($debug);
  912.         if ($targs[1] =~ /(.*)-p(.*)/) {
  913.             $targs[1] = "$1 $2";
  914.             print("Found -p in args file\n") if ($debug);
  915.             $prune = 1;
  916.         }
  917.         chop($targs[0]);
  918.         chop($targs[1]);
  919.         }
  920.         $tmp = "$buffer $targs[0] update $args $targs[1]";
  921.         printf("$tmp\n") if ($debug);
  922.         system($tmp);
  923.         if (&Unpack($i)) {
  924.         printf(STDERR "Unpack of $i failed.\n");
  925.         $status = 1;
  926.         }
  927.         if ($prune) {
  928.         if (&Prune($i)) {
  929.             printf(STDERR "Prune of $i failed.\n");
  930.             $status = 1;
  931.         }
  932.         }
  933.  
  934.         &Chdir($pwd) == 0 || return 1; 
  935.     }
  936.     }
  937.     return $status;
  938. }
  939.  
  940. #
  941. # Changed($path)
  942. #
  943. # Use the "cvs info" command to see if the contents of the current directory
  944. # or its subdirectories have been changed by the user.  The modified
  945. # parameter is set to 1 if they have been.
  946. #
  947. # Results: 0 if successful, 1 otherwise; 0 if not modified, 1 otherwise
  948. #
  949. # Side effects: 
  950. #
  951. sub Changed {
  952.     local($path) = shift;
  953.     local($modified) = 0;
  954.     local($status) = 0;
  955.     if (!-d "CVS.adm") {
  956.     return 0;
  957.     }
  958.     open(CHG, "cvs -d $cvsroot info |") ||
  959.     return &Error(1, "Can't do cvs info on $path: $!\n");
  960.     while (<CHG>) {
  961.     if (/^[MC]\s+(\S+)/) {
  962.         printf("$path/$1 has been modified\n");
  963.         $modified = 1;
  964.     } elsif(/^A\s+(\S+)/) {
  965.         printf("$path/$1 has been added\n");
  966.         $modified = 1;
  967.     } elsif(/^R\s+(\S+)/) {
  968.         printf("$path/$1 has been deleted\n");
  969.         $modified = 1;
  970.     }
  971.     }
  972.     close(CHG);
  973.     ($status, @results) = &AllSubdirs($path, "Changed");
  974.     if ($status) {
  975.     return $status;
  976.     }
  977.     while ($#results >= $[) {
  978.     local($substatus) = shift(@results);
  979.     local($submod) = shift(@results);
  980.     if ($substatus) {
  981.         $status = 1;
  982.     }
  983.     if ($submod) {
  984.         $modified = 1;
  985.     }
  986.     }
  987.     return ($status, $modified);
  988. }
  989.  
  990. #
  991. # DoneCmd(@modules)
  992. #
  993. # Process the "done" command.  The user is deleted from the list of users
  994. # for each module.  If the -d flag is specified then the snapshot is
  995. # deleted as well.  If the user has made changes to the snapshot the user
  996. # is warned before the "done" command is completed.
  997. #
  998. # Results: 0 if successful, 1 otherwise
  999. #
  1000. # Side effects: 
  1001. #
  1002. sub DoneCmd {
  1003.     local(@modules) = @_;
  1004.     local($status) = 0;
  1005.     local($i);
  1006.     local($me) = getlogin;
  1007.     local($pwd) = $ENV{'PWD'};
  1008.     local($repos, $found);
  1009.     local($delete);
  1010.     local($modified);
  1011.     local(@options) = (
  1012.     "d", $OPT_TRUE, *delete, "Delete module",
  1013.     );
  1014.  
  1015.     $recurse = 1;
  1016.     undef($cvsargs);
  1017.     &Opt_Parse(*modules, @options, $OPT_OPTIONS_FIRST); 
  1018.     if ($#modules < $[) {
  1019.     return &Error(1, "Done command requires a list of modules\n");
  1020.     }
  1021.     # Make sure all the modules are unlocked, then lock them.
  1022.     $status = &Lock("r",@modules); 
  1023.     if ($status) {
  1024.     return $status;
  1025.     }
  1026. module:
  1027.     foreach $i (@modules) {
  1028.     $ok = 0;
  1029.     if (! -d $i) {
  1030.         printf("Directory $i not found.\n");
  1031.         next module;
  1032.     }
  1033.     &Chdir($i) == 0 || return 1; 
  1034.     ($status, $modified) = &Changed($i);
  1035.     if ($status) {
  1036.         printf(STDERR "Unable to determine if $i module has changed.\n");
  1037.         $modified = 1;
  1038.     }
  1039.     if ($modified == 1) {
  1040.         printf("Do you wish to continue? [y/n] ");
  1041. prompt:
  1042.         while(1) {
  1043.         $answer = <STDIN>;
  1044.         chop($answer);
  1045.         last prompt if ($answer eq "y");
  1046.         next module if ($answer eq "n");
  1047.         printf("Please answer with \"y\" or \"n\": ");
  1048.         }
  1049.     } elsif ($modified == 1) {
  1050.         next module;
  1051.     }
  1052.  
  1053.     # Update the user file.
  1054.     $repos = &Repository(".");
  1055.     next module if (!defined($repos));
  1056.     if (!open(DONE1, "$repos/$userFile")) {
  1057.         printf("Module $i is not checked out\n");
  1058.         next module;
  1059.     }
  1060.     if (!open(DONE2, ">$repos/$tmpfile")) {
  1061.         printf("Can't open $repos/$tmpfile: $!\n");
  1062.         $status = 1;
  1063.         next module;
  1064.     }
  1065.     $me = getlogin;
  1066.     $found = 0;
  1067.     while (<DONE1>) {
  1068.         if (/^$me\s+([\w\/\.]+)\s+(.*)/) {
  1069.         if ($1 eq "$pwd/$i") {
  1070.             $found = 1;
  1071.             next;
  1072.         }
  1073.         }
  1074.         print DONE2 $_;
  1075.     }
  1076.     close(DONE1);
  1077.     close(DONE2);
  1078.     if (!$found) {
  1079.         printf("Module $i is not checked out\n");
  1080.         next module;
  1081.     }
  1082.     if (!rename("$repos/$tmpfile", "$repos/$userFile")) {
  1083.         printf("Rename of $repos/$tmpfile to $repos/$userFile failed:$!\n");
  1084.         unlink("$repos/$tmpfile");
  1085.         next module;
  1086.     }
  1087.     $ok = 1;
  1088.     }
  1089.     continue {
  1090.     &Chdir($pwd) == 0 || return 1; 
  1091.     if ($ok && $delete) {
  1092.         system("rm -rf $i");
  1093.         if ($?) {
  1094.         printf("Delete of $i failed: $?\n");
  1095.         }
  1096.     }
  1097.     }
  1098.     return $status;
  1099. }
  1100.  
  1101. #
  1102. # AllSubdirs(path, routine, args)
  1103. #
  1104. # Call a routine for each subdirectory of the current directory. The
  1105. # current working directory is changed to the subdirectory before the 
  1106. # routine is called, and the path is modified to reflect this change.
  1107. # The path is passed to the routine when it is called. The routine is
  1108. # called for all subdirectories even if one returns an non-zero status,
  1109. # although this function will then return a non-zero status.
  1110. # Any additional arguments for the routine are passed after the path
  1111. # argument.
  1112. #
  1113. # Results: 0 if successful, 1 if the routine returned non-zero for any
  1114. #         of the subdirectories.
  1115. #
  1116. # Side effects: 
  1117. #
  1118. sub AllSubdirs {
  1119.     local($path) = shift;
  1120.     local($routine) = shift;
  1121.     local($pwd) = $ENV{'PWD'};
  1122.     local($substatus);
  1123.     local($dir);
  1124.     local(@results);
  1125.     local(@status);
  1126.     local(@subdirs);
  1127.  
  1128.     printf(STDERR "AllSubdirs of $routine on $pwd\n") if ($debug);
  1129.     opendir(THISDIR, ".") || 
  1130.     return &Error(1, "Opendir of $path failed: $!\n"); 
  1131.     @subdirs = grep((-d) && (!/^\./) && (! -l) && ($_ ne 'CVS.adm'), 
  1132.             readdir(THISDIR));
  1133.     print("AllSubdirs: @subdirs\n") if ($debug);
  1134.     close(THISDIR);
  1135.     print "@subdirs\n****\n" if ($debug); 
  1136.     foreach $dir (@subdirs) {
  1137.     printf("\t$dir\n") if ($debug);
  1138.     &Chdir($dir) == 0 || return 1; 
  1139.     push(@results, &$routine($path . "/$dir", @_));
  1140.     &Chdir($pwd) == 0 || ($status = 1); 
  1141.     }
  1142.     if (wantarray) {
  1143.     return ($status, @results);
  1144.     }
  1145.     if ($status) {
  1146.     return $status;
  1147.     }
  1148.     @status = grep("$_ != 0", @results);
  1149.     if ($#status >= $[) {
  1150.     return $status[0];
  1151.     }
  1152.     return 0;
  1153. }
  1154.  
  1155.  
  1156. #
  1157. # VerifyCurrent($path, *stale, *modified)
  1158. #
  1159. # Check the status of the files in the current directory and its 
  1160. # subdirectories to see if they are out of date.
  1161. #
  1162. # Results: 0 if successful, 1 otherwise;
  1163. #
  1164. # Side effects: 
  1165. #
  1166. sub VerifyCurrent {
  1167.     local($path) = shift;
  1168.     local(*stale) = shift;
  1169.     local(*modified) = shift;
  1170.     local($pwd) = $ENV{'PWD'};
  1171.     local($status) = 0;
  1172.     local($substatus) = 0;
  1173.     local($current) = 1;
  1174.     local($mod) = 0;
  1175.  
  1176.     printf("Verifying that $path is current\n") if ($debug);
  1177.     if (!-d "CVS.adm") {
  1178.     return 0;
  1179.     }
  1180.     open(CHK, "cvs -d $cvsroot info |") ||
  1181.     return &Error(1, "Can't get info for $path: $!\n");
  1182.     while(<CHK>) {
  1183.     if (/^U\s+(\S+)/) {
  1184.         printf("File $path/$1 is out of date or needs to be added.\n");
  1185.         $current = 0;
  1186.     } elsif (/^D\s+(\S+)/) {
  1187.         printf("File $path/$1 has been removed from the repository.\n");
  1188.         $current = 0;
  1189.     } elsif (/^C\s+(\S+)/) {
  1190.         printf("File $path/$1 is out of date.\n");
  1191.         $current = 0;
  1192.     } elsif (/^[MARC]/) {
  1193.         $mod = 1;
  1194.     } 
  1195.     }
  1196.     close(CHK);
  1197.     if (!$current) {
  1198.     printf("$path is not current\n") if ($debug);
  1199.     push(@stale, $path);
  1200.     }
  1201.     if ($mod) {
  1202.     printf("$path has been modified\n") if ($debug);
  1203.     push(@modified, $path);
  1204.     }
  1205.     if ($recurse) {
  1206.     $status = &AllSubdirs($path, "VerifyCurrent", *stale, *modified);
  1207.     }
  1208.     return $status;
  1209. }
  1210.  
  1211. #
  1212. # UpdateInstalled(@files)
  1213. #
  1214. # Update the installed copy of the sources.  This is done on commit.
  1215. # If @files is not specified then the entire directory and its subdirectories
  1216. # are updated.
  1217. #
  1218. # Results: 0 if successful, 1 otherwise
  1219. #
  1220. # Side effects: The installed sources are updated.
  1221. #
  1222. sub UpdateInstalled {
  1223.     local(@files) = @_;
  1224.     local($dir);
  1225.     local($pwd) = $ENV{'PWD'};
  1226.     local($module);
  1227.  
  1228.     printf(STDERR "UpdateInstalled\n") if ($debug);
  1229.     $module = &GetModuleName;
  1230.     if (!defined($module)) {
  1231.     print("Can't file module name for dir $pwd\n");
  1232.     return 1;
  1233.     }
  1234.     $dir = &ReadFile("$installdir/$module/SCVSCVS.adm/Repository", 1);
  1235.     if (!defined($dir)) {
  1236.     return 1;
  1237.     }
  1238.     chop($dir);
  1239.     &Chdir("$installdir/$dir") == 0 || return 1;
  1240.     &UpdateCmd(0, "-Q", @files) == 0 || return 1;
  1241.     &Chdir("$pwd") == 0 || return 1;
  1242.     return 0;
  1243. }
  1244.  
  1245.  
  1246.  
  1247. #
  1248. # Commit
  1249. #
  1250. # Commit the current directory and its subdirectories.
  1251. #
  1252. # Results: 0 if successful, 1 otherwise
  1253. #
  1254. # Side effects: 
  1255. #
  1256. sub Commit {
  1257.     local($path) = shift;
  1258.     local($args) = shift;
  1259.     local($pwd) = $ENV{'PWD'};
  1260.     local($status) = 0;
  1261.     local($output);
  1262.     local($tail);
  1263.  
  1264.  
  1265.     printf(STDERR "CommitDir $path\n") if ($debug);
  1266.     if (!-d "CVS.adm") {
  1267.     return 0;
  1268.     }
  1269.     printf("$path:\n");
  1270.     $tail = substr($path, rindex($path, '/') + 1);
  1271.     #
  1272.     # Before we commit the SCVS links file we remove all the deleted links
  1273.     # from it.
  1274.     #
  1275.     if ($tail eq "SCVS") {
  1276.     if (open(CMTDIR1, "$linkFile")) {
  1277.         open(CMTDIR2, ">$tmpfile") ||
  1278.         return &Error(1, "Open of $path/$tmpfile failed: $!\n");
  1279.         while(<CMTDIR1>) {
  1280.         next if (/^[*]/);
  1281.         print CMTDIR2 $_;
  1282.         }
  1283.         close(CMTDIR1);
  1284.         close(CMTDIR2);
  1285.         if (!rename("$tmpfile", "$linkFile")) {
  1286.         printf("Rename of $tmpfile to $linkFile failed:$!\n");
  1287.         unlink("$tmpfile");
  1288.         return 1;
  1289.         }
  1290.         system("cvs -d $cvsroot $cvsCmdArgs ci -f -m scvs links");
  1291.     }
  1292.     }
  1293.     system("cvs -d $cvsroot $cvsCmdArgs ci -f -a $args");
  1294.     return $status;
  1295. }
  1296.  
  1297. #
  1298. # CommitCmd(@names)
  1299. #
  1300. # Commit any changes to the modules or files. 
  1301. # Otherwise all changed files in the current directory and any subdirectories
  1302. # are committed.  Before anything is committed it is checked that all
  1303. # files are up-to-date.  If they aren't, a message is printed and the
  1304. # commit is not done.
  1305. #
  1306. # Results: 0 if successful, 1 otherwise
  1307. #
  1308. # Side effects: 
  1309. #
  1310.  
  1311. sub CommitCmd {
  1312.     local(@names) = @_;
  1313.     local($pwd, $i);
  1314.     local($status) = 0;
  1315.     local($path);
  1316.     local(@stale, @modified);
  1317.     local($tmp);
  1318.     local($args);
  1319.     local($quiet) = 0;
  1320.     local(@options) = (
  1321.     "l", $OPT_FALSE, *recurse, "Don't recurse on subdirs",
  1322.     "f", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1323.     "n", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1324.     "m", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  1325.     "r", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  1326.     "q", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1327.     "Q", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1328.     );
  1329.  
  1330.     $recurse = 1;
  1331.     undef($cvsargs);
  1332.     &Opt_Parse(*names, @options, $OPT_OPTIONS_FIRST | $OPT_NO_SPACE);
  1333.     $args = $cvsargs;
  1334.  
  1335.     if ($#names < $[) {
  1336.     push(@names, ".");
  1337.     }
  1338.     if ($args =~ /-q|-Q/) {
  1339.     $quiet = 1;
  1340.     } else {
  1341.     $args .= " -q";
  1342.     }
  1343.     if (! $quiet) {
  1344.     print("Verifying that sources are up-to-date.\n");
  1345.     }
  1346.     if (! -d $names[0]) {
  1347.     $status = &Lock("w","."); 
  1348.     if ($status) {
  1349.         return $status;
  1350.     }
  1351.     $status = &VerifyCurrent(".", *stale, *modified);
  1352.     if ($status) {
  1353.         return $status;
  1354.     }
  1355.     if ($#stale >= $[) {
  1356.         printf("Update your sources using \"scvs update\".\n");
  1357.         return $status;
  1358.     }
  1359.     $tmp = "cvs -d $cvsroot $cvsCmdArgs ci -f $args @names";
  1360.     system($tmp);
  1361.     $status = &UpdateInstalled(@names);
  1362.     } else {
  1363.     $status = &Lock("w",@names); 
  1364.     if ($status) {
  1365.         return $status;
  1366.     }
  1367.     $pwd = $ENV{'PWD'};
  1368.  
  1369.     #
  1370.     # All the modules and their subdirectories must be up-to-date.
  1371.     #
  1372. module:
  1373.     foreach $i (@names) {
  1374.         &Chdir($i) == 0 || return 1; 
  1375.         $status = &VerifyCurrent($i, *stale, *modified);
  1376.         if ($status) {
  1377.         return $status;
  1378.         }
  1379.         &Chdir($pwd) == 0 || return 1; 
  1380.     }
  1381.     
  1382.     if ($#stale >= $[) {
  1383.         printf("Update your sources using \"scvs update\".\n");
  1384.         return $status;
  1385.     }
  1386.     
  1387.     if (! $quiet) {
  1388.         print("Committing modified directories.\n");
  1389.     }
  1390.     #
  1391.     # Commit all directories that were modified.
  1392.     #
  1393.     foreach $i (@modified) {
  1394.         &Chdir($i) == 0 || return 1; 
  1395.         $status = &Commit($i, $args);
  1396.         &Chdir($pwd) == 0 || return 1; 
  1397.     }
  1398.     if (defined($installdir)) {
  1399.         # 
  1400.         # Update the installed copy of the sources.
  1401.         #
  1402.         if (! $quiet) {
  1403.         print("Updating installed copies.\n");
  1404.         }
  1405.         foreach $i (@modified) {
  1406.         &Chdir($i) == 0 || return 1; 
  1407.         $status = &UpdateInstalled;
  1408.         &Chdir($pwd) == 0 || return 1; 
  1409.         }
  1410.     }
  1411.     }
  1412.     return $status;
  1413. }
  1414.  
  1415.  
  1416. #
  1417. # WhoCmd(@modules)
  1418. #
  1419. # Print the names of users who have the modules checked out.
  1420. #
  1421. # Results: 0 if successful, 1 otherwise
  1422. #
  1423. # Side effects: 
  1424. #
  1425.  
  1426. sub WhoCmd {
  1427.     local(@modules) = @_;
  1428.     local($pwd, $i);
  1429.     local($status) = 0;
  1430.     local($cvsdir, @who, $user, %users, $line);
  1431.  
  1432.     if (!defined(%moduleToRepos)) {
  1433.     &ModMap;
  1434.     }
  1435.     if ($#modules < $[) {
  1436.     push(@modules, ".");
  1437.     }
  1438.     $status = &Lock("r",@modules); 
  1439.     if ($status) {
  1440.     return $status;
  1441.     }
  1442.     $pwd = $ENV{'PWD'};
  1443.  
  1444. module:
  1445.     foreach $i (@modules) {
  1446.     if ($i eq ".") {
  1447.         $i = &GetModuleName;
  1448.         if (!defined($i)) {
  1449.         $status = 1;
  1450.         next module;
  1451.         }
  1452.     }
  1453.     if (!defined($moduleToRepos{$i})) {
  1454.         printf(STDERR "$i module does not exist.\n");
  1455.         $status = 1;
  1456.         next module;
  1457.     }
  1458.     $cvsdir = $cvsroot . "/" . $moduleToRepos{$i};
  1459.     @who = &ReadFile("$cvsdir/$userFile", 1);
  1460.     foreach $line (@who) {
  1461.         ($user) = split(' ', $line);
  1462.         $users{$user} = 1;
  1463.     }
  1464.     foreach $user (keys %users) {
  1465.         printf("$user\n");
  1466.     }
  1467.     }
  1468.     return $status;
  1469. }
  1470.  
  1471. #
  1472. # AddCmd(@names)
  1473. #
  1474. # Add a file, directory, or symbolic link to a directory.
  1475. #
  1476. # Results: 0 if successful, 1 otherwise
  1477. #
  1478. # Side effects: 
  1479. #
  1480.  
  1481. sub AddCmd {
  1482.     local(@names) = @_;
  1483.     local($i);
  1484.     local($status) = 0;
  1485.     local(%links);
  1486.     local($pwd) = $ENV{'PWD'};
  1487.     local($module);
  1488.     local($args);
  1489.     local(@options) = (
  1490.     "m", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  1491.     );
  1492.  
  1493.     undef($cvsargs);
  1494.     &Opt_Parse(*names, @options, $OPT_OPTIONS_FIRST | $OPT_NO_SPACE);
  1495.     $args = $cvsargs;
  1496.  
  1497.     if ($#names < $[) {
  1498.     return &Error(1, "Add command requires list of files\n");
  1499.     }
  1500.     $module = &GetModuleName;
  1501.     if (!defined($module)) {
  1502.     return 1;
  1503.     }
  1504. name:
  1505.     foreach $i (@names) {
  1506.     if (-l $i) {
  1507.         local($target) = readlink($i);
  1508.         if (!defined($target)) {
  1509.         printf("$i does not exist\n");
  1510.         $status = 1;
  1511.         next name;
  1512.         }
  1513.         if (open(ADD, "SCVS/$linkFile")) {
  1514.         while(<ADD>) {
  1515.             if (/^$i\s+(\S+)/) {
  1516.             if ($target ne $1) {
  1517.                 printf("Link $i already points to $1.\n");
  1518.             } else {
  1519.                 printf("Link $i already added.\n");
  1520.             }
  1521.             $status = 1;
  1522.             close(ADD);
  1523.             next name;
  1524.             }
  1525.         }
  1526.         close(ADD);
  1527.         } elsif (! -f "SCVS/$linkFile") {
  1528.         open(ADD, ">SCVS/$linkFile") ||
  1529.             return &Error(1, "Can't open SCVS/$linkFile: $!\n");
  1530.         printf(ADD 
  1531.         "# This file is used by scvs and contains symbolic link\n");
  1532.         printf(ADD 
  1533.         "# information.  Each line is of the form \"link target\"\n");
  1534.         printf(ADD "# \$Header\n");
  1535.         close(ADD);
  1536.         &Chdir("SCVS") == 0 || return 1; 
  1537.         printf("Adding $linkFile directory\n") if ($debug);
  1538.         system("cvs -d $cvsroot add -m \"sym links\" $linkFile");
  1539.         &Chdir($pwd) == 0 || return 1; 
  1540.         } else {
  1541.         return &Error(1, "Open of SCVS/$linkFile failed: $!\n");
  1542.         }
  1543.         $links{$i} = $target;
  1544.     } else {
  1545.         system("cvs -d $cvsroot $cvsCmdArgs add $args $i");
  1546.         if (-d $i) {
  1547.         # 
  1548.         # If we are adding a directory then we should create an
  1549.         # SCVS subdirectory in it.
  1550.         #
  1551.         if (! -d "$i/SCVS") {
  1552.             mkdir("$i/SCVS", 0770) ||
  1553.             return &Error(1, "Mkdir of $i/SCVS failed: $!\n");
  1554.             &Chdir("$i/SCVS") == 0 || return 1; 
  1555.             open(ADD, ">module") ||
  1556.             return &Error(1, "Open of $i/SCVS/module failed: $!\n");
  1557.             printf(ADD "$module\n");
  1558.             close(ADD);
  1559.             system("cvs -d $cvsroot add module");
  1560.             &Chdir($pwd) == 0 || return 1; 
  1561.         }
  1562.         }
  1563.     }
  1564.     if (defined(%links)) {
  1565.         open(ADD, ">>SCVS/$linkFile") ||
  1566.         return &Error(1, "Open of SCVS/$linkFile failed: $!\n");
  1567.         while (($i, $target) = each(%links)) {
  1568.         printf("Adding link $i -> $target\n") if ($debug);
  1569.         printf(ADD "%-24s %s\n", $i, $target);
  1570.         }
  1571.         close(ADD);
  1572.     }
  1573.     }
  1574.     return $status;
  1575. }
  1576. #
  1577. # RemoveCmd(@names)
  1578. #
  1579. # Removes a file, directory, or symbolic link from a directory.
  1580. #
  1581. # Results: 0 if successful, 1 otherwise
  1582. #
  1583. # Side effects: 
  1584. #
  1585.  
  1586. sub RemoveCmd {
  1587.     local(@names) = @_;
  1588.     local($i);
  1589.     local($status, %links, @delete) = 0;
  1590.  
  1591.     if ($#names < $[) {
  1592.     return &Error(1, "Remove command requires list of files\n");
  1593.     }
  1594.     if (open(RM, "SCVS/$linkFile")) {
  1595.     while(<RM>) {
  1596.         next if (/^#/);
  1597.         if (/^([^*]\S+)\s+(\S+)/) {
  1598.         printf("Found link $1 -> $2\n") if ($debug);
  1599.         $links{$1} = $2;
  1600.         }
  1601.     }
  1602.     close(RM);
  1603.     }
  1604. name:
  1605.     foreach $i (@names) {
  1606.     if (-e $i) {
  1607.         if (-d $i) {
  1608.         print("Ignoring remove of directory $i\n");
  1609.         next name;
  1610.         }
  1611.         printf("Deleting existing $i\n");
  1612.         if (!unlink("$i")) {
  1613.         printf("Unlink failed: $!\n");
  1614.         $status = 1;
  1615.         next name;
  1616.         }
  1617.     }
  1618.     if (defined($links{$i})) {
  1619.         printf("Putting $i on delete list\n") if ($debug);
  1620.         push(@delete, $i);
  1621.     } else {
  1622.         system("cvs -d $cvsroot $cvsCmdArgs remove $i");
  1623.     }
  1624.     }
  1625.     if ($#delete >= $[) {
  1626.     if (!open(RM1, "SCVS/$linkFile")) {
  1627.         printf("Can't open SCVS/$linkFile: $!\n");
  1628.         $status = 1;
  1629.         next name;
  1630.     }
  1631.     if (!open(RM2, ">$tmpfile")) {
  1632.         printf("Can't open $tmpfile: $!\n");
  1633.         $status = 1;
  1634.         next name;
  1635.     }
  1636. line:
  1637.     while (<RM1>) {
  1638.         if (/^([^#*]\S+)\s+(\S+)/) {
  1639.         for ($i = 0; $i <= $#delete; $i++) {
  1640.             if ($delete[$i] eq $1) {
  1641.             splice(@delete, $i, 1);
  1642.             print RM2 "*$_";
  1643.             next line;
  1644.             }
  1645.         }
  1646.         }
  1647.         print RM2 $_;
  1648.     }
  1649.     close(RM1);
  1650.     close(RM2);
  1651.     if (!rename("$tmpfile", "SCVS/$linkFile")) {
  1652.         printf("Rename of $tmpfile to SCVS/$linkFile failed:$!\n");
  1653.         unlink("$tmpfile");
  1654.         $status = 1;
  1655.     }
  1656.     }
  1657.     return $status;
  1658. }
  1659. #
  1660. # Info($path)
  1661. #
  1662. # Prints out status information for the current directory and recurses
  1663. # on subdirectories.
  1664. #
  1665. # Results: 0 if successful, 1 otherwise
  1666. #
  1667. # Side effects: 
  1668. #
  1669. sub Info {
  1670.     local($path) = shift;
  1671.     local($tail);
  1672.     local($diff) = 0;
  1673.     local($cat) = 0;
  1674.     local($i);
  1675.     local($pwd) = $ENV{'PWD'};
  1676.  
  1677.     if (!-d "CVS.adm") {
  1678.     return 0;
  1679.     }
  1680.     print("$path\n");
  1681.     $tail = substr($path, rindex($path, '/') + 1);
  1682.     if ($tail eq "SCVS") {
  1683.     return 0;
  1684.     }
  1685.     system("cvs -d $cvsroot $cvsCmdArgs info ");
  1686.     if (-d "SCVS") {
  1687.     &Chdir("SCVS") == 0 || return 1;
  1688.     open(INFO, "cvs -d $cvsroot $cvsCmdArgs info |") ||
  1689.         return &Error(1, "Can't do cvs info on $path: $!\n");
  1690.     while(<INFO>) {
  1691.         if (/^[UMC]\s+$linkFile/) {
  1692.         $diff = 1;
  1693.         last;
  1694.         } elsif (/^[AD]\s+$linkFile/) {
  1695.         $cat = 1;
  1696.         last;
  1697.         }
  1698.     }
  1699.     close(INFO);
  1700.     if ($diff) {
  1701.         local(%updated);
  1702.         open(INFO, "cvs -d $cvsroot diff $linkFile |") ||
  1703.         return &Error(1, "Can't do cvs diff on $path/$linkFile: $!\n");
  1704.         while(<INFO>) {
  1705.         if (/^>\s+([^*]\S+)/) {
  1706.             printf("A %s\@\n", $1);
  1707.         } elsif (/^>\s+[*](\S+)/) {
  1708.             printf("R %s\@\n", $1);
  1709.             delete $updated{$1};
  1710.         } elsif (/^<\s+([^*]\S+)/) {
  1711.             $updated{$1} = 1;
  1712.         } elsif (/^<\s+[*](\S+)/) {
  1713.             printf("D %s\@\n", $1);
  1714.         }
  1715.         }
  1716.         close(INFO);
  1717.         foreach $i (keys %updated) {
  1718.         printf("U %s\@\n", $i);
  1719.         }
  1720.     }
  1721.     if ($cat) {
  1722.         open(INFO, "$linkFile") ||
  1723.         return &Error(1, "Open of $linkFile failed: $!\n");
  1724.         while(<INFO>) {
  1725.         next if (/^#/);
  1726.         if (/^([^*]\S+)/) {
  1727.             printf("A %s\@\n", $1);
  1728.         } elsif (/^([*]\S+)/) {
  1729.             printf("R %s\@\n", $1);
  1730.         }
  1731.         }
  1732.         close(INFO);
  1733.     }
  1734.     &Chdir($pwd) == 0 || return 1;
  1735.     }
  1736.     if (($recurse) && ($#files < $[)) {
  1737.     $status = &AllSubdirs($path, "Info");
  1738.     }
  1739. }
  1740.  
  1741. #
  1742. # InfoCmd(@modules)
  1743. #
  1744. # Prints out status information for the given modules.
  1745. #
  1746. # Results: 0 if successful, 1 otherwise
  1747. #
  1748. # Side effects: 
  1749. #
  1750.  
  1751. sub InfoCmd {
  1752.     local(@modules) = @_;
  1753.     local($pwd, $i);
  1754.     local($status) = 0;
  1755.     local(@options) = ("l", $OPT_FALSE, *recurse, "Don't recurse on subdirs");
  1756.     local(@targs);
  1757.  
  1758.     $recurse = 1;
  1759.     undef($cvsargs);
  1760.     &Opt_Parse(*modules, @options, $OPT_OPTIONS_FIRST);
  1761.     print "@modules\n" if ($debug);
  1762.  
  1763.     if ($#modules < $[) {
  1764.     push(@modules, ".");
  1765.     }
  1766.     if (-e "SCVS/$argFile") {
  1767.     @targs = &ReadFile("SCVS/$argFile", 1);
  1768.     if ($targs[1] =~ /(.*)-p(.*)/) {
  1769.         $targs[1] = "$1 $2";
  1770.     }
  1771.     chop($targs[0]);
  1772.     $cvsCmdArgs .= $targs[0];
  1773.     }
  1774.     if (! -d $modules[0]) {
  1775.     $status = &Lock("r","."); 
  1776.     if ($status) {
  1777.         return $status;
  1778.     }
  1779.     system("cvs -d $cvsroot $cvsCmdArgs info @modules");
  1780.     } else {
  1781.     $status = &Lock("r",@modules);
  1782.     if ($status) {
  1783.         return $status;
  1784.     }
  1785.     $pwd = $ENV{'PWD'};
  1786.     foreach $i (@modules) {
  1787.         printf("InfoCmd %i\n") if ($debug);
  1788.         &Chdir($i) == 0 || return 1; 
  1789.         $status = &Info($i);
  1790.         if ($status) {
  1791.         return $status;
  1792.         }
  1793.         &Chdir($pwd) == 0 || return 1; 
  1794.     }
  1795.     }
  1796.     return $status;
  1797. }
  1798.  
  1799. #
  1800. # DiffFile($path, $file, $args, $current)
  1801. #
  1802. # Prints out status information for the current directory and recurses
  1803. # on subdirectories.
  1804. #
  1805. # Results: 0 if successful, 1 otherwise
  1806. #
  1807. # Side effects: 
  1808. #
  1809. sub DiffFile {
  1810.     local($path) = shift;    # Current path.
  1811.     local($file) = shift;    # File to diff.
  1812.     local($args) = shift;    # args to cvs diff.
  1813.     local($current) = shift;    # Should we diff with current version.
  1814.     local($tail);
  1815.     local($pwd) = $ENV{'PWD'};
  1816.     local($status) = 0;
  1817.     local($version) = "";
  1818.     local($repository);
  1819.  
  1820.     if (!-d "CVS.adm") {
  1821.     return 0;
  1822.     }
  1823.     $repository = &Repository(".");
  1824.     if (!defined($repository)) {
  1825.     print("Repository not found\n") if ($debug);
  1826.     return 0;
  1827.     }
  1828.     printf("Repository is $repository\n") if ($debug);
  1829.     if (!-e "$repository/$file,v") {
  1830.     return 0;
  1831.     }
  1832.     if ($current) {
  1833.     open(DIFF, "cvs -d $cvsroot status $file |") ||
  1834.         return &Error(1, "Can't get status for $path/$file: $!\n");
  1835.     while(<DIFF>) {
  1836.         if (/^RCS:\s+(\S+)/) {
  1837.         $version = "-r $1";
  1838.         last;
  1839.         }
  1840.     }
  1841.     close(DIFF);
  1842.     }
  1843.     system("cvs -d $cvsroot $cvsCmdArgs diff $version $args $file");
  1844. }
  1845.  
  1846. #
  1847. # Diff($path, $args, $current)
  1848. #
  1849. # Prints out status information for the current directory and recurses
  1850. # on subdirectories.
  1851. #
  1852. # Results: 0 if successful, 1 otherwise
  1853. #
  1854. # Side effects: 
  1855. #
  1856. sub Diff {
  1857.     local($path) = shift;    # Current path.
  1858.     local($args) = shift;    # args to cvs diff.
  1859.     local($current) = shift;    # Should we diff with current version.
  1860.     local($tail);
  1861.     local($pwd) = $ENV{'PWD'};
  1862.     local($file);
  1863.     local($status) = 0;
  1864.  
  1865.     if (!-d "CVS.adm") {
  1866.     return 0;
  1867.     }
  1868.     $tail = substr($path, rindex($path, '/') + 1);
  1869.     if ($tail eq "SCVS") {
  1870.     return 0;
  1871.     }
  1872.     opendir(THISDIR, ".") || return &Error(1, "Opendir of $path failed: $!\n");
  1873.     foreach $file (grep(-f, readdir(THISDIR))) {
  1874.     printf(STDERR "$file\n") if ($debug);
  1875.     $status = &DiffFile($path, $file, $args, $current);
  1876.     if ($status) {
  1877.         return $status;
  1878.     }
  1879.     }
  1880.     if ($recurse) {
  1881.     $status = &AllSubdirs($path, "Diff", $args, $current);
  1882.     }
  1883. }
  1884.  
  1885.  
  1886.  
  1887. #
  1888. # DiffCmd(@modules)
  1889. #
  1890. # Does an rcsdiff on the modules or directories
  1891. #
  1892. # Results: 0 if successful, 1 otherwise
  1893. #
  1894. # Side effects: 
  1895. #
  1896.  
  1897. sub DiffCmd {
  1898.     local(@modules) = @_;
  1899.     local($pwd, $i);
  1900.     local($status) = 0;
  1901.     local($current) = 0;
  1902.     local(@options) = (
  1903.     "R", $OPT_TRUE, *current, "Diff with current version",
  1904.     "l", $OPT_FALSE, *recurse, "Recurse on subdirectories",
  1905.     "b", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1906.     "i", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1907.     "w", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1908.     "t", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1909.     "c", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1910.     "e", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1911.     "f", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1912.     "h", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1913.     "n", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  1914.     "r", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  1915.     );
  1916.  
  1917.     $recurse = 1;
  1918.     undef($cvsargs);
  1919.     &Opt_Parse(*modules, @options, $OPT_OPTIONS_FIRST | $OPT_NO_SPACE);
  1920.     print "@modules\n" if ($debug);
  1921.     if ($#modules < $[) {
  1922.     push(@modules, ".");
  1923.     }
  1924.     if (! -d $modules[0]) {
  1925.     $status = &Lock("r","."); 
  1926.     if ($status) {
  1927.         return $status;
  1928.     }
  1929.     foreach $i (@modules) {
  1930.         &DiffFile(".", $i, $cvsargs, $current);
  1931.     }
  1932.     } else {
  1933.     $status = &Lock("r",@modules);
  1934.     if ($status) {
  1935.         return $status;
  1936.     }
  1937.     $pwd = $ENV{'PWD'};
  1938.  
  1939.     foreach $i (@modules) {
  1940.         printf("DiffCmd $i\n") if ($debug);
  1941.         &Chdir($i) == 0 || return 1; 
  1942.         $status = &Diff($i, $cvsargs, $current);
  1943.         if ($status) {
  1944.         return $status;
  1945.         }
  1946.         &Chdir($pwd) == 0 || return 1; 
  1947.     }
  1948.     }
  1949.     return $status;
  1950. }
  1951.  
  1952. #
  1953. # Cvs($path, $command)
  1954. #
  1955. # Run a cvs command in the current directory and its subdirectories.
  1956. # Any output from the command is printed.  The command is not executed
  1957. # in any "SCVS" subdirectories.
  1958. #
  1959. # Results: 0 if successful, 1 otherwise
  1960. #
  1961. # Side effects: 
  1962. #
  1963. sub Cvs {
  1964.     local($path) = shift;
  1965.     local($command) = shift;
  1966.     local($pwd) = $ENV{'PWD'};
  1967.     local($status) = 0;
  1968.     local($output, $tail);
  1969.  
  1970.     if (!-d "CVS.adm") {
  1971.     return 0;
  1972.     }
  1973.     $tail = substr($path, rindex($path, '/') + 1);
  1974.     if ($tail eq "SCVS") {
  1975.     return 0;
  1976.     }
  1977.     printf("%s\n", $path);
  1978.     system("cvs -d $cvsroot $cvsCmdArgs $command");
  1979.     if ($recurse) {
  1980.     $status = &AllSubdirs($path, "Cvs", $command);
  1981.     }
  1982.     return $status;
  1983. }
  1984.  
  1985.  
  1986. #
  1987. # CvsCmd($command, @modules)
  1988. #
  1989. # Runs a cvs command on each module and its subdirectories.
  1990. # Any output from the command is printed.
  1991. #
  1992. # Results: 0 if successful, 1 otherwise
  1993. #
  1994. # Side effects: 
  1995. #
  1996.  
  1997. sub CvsCmd {
  1998.     local($command) = shift;
  1999.     local(@modules) = @_;
  2000.     local($i, @args);
  2001.     local($status) = 0;
  2002.     local($path);
  2003.     local($pwd) = $ENV{'PWD'};
  2004.     local(@options) = (
  2005.     "l", $OPT_FALSE, *recurse, "Don't recurse on subdirs",
  2006.     "L", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  2007.     "R", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  2008.     "h", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  2009.     "t", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  2010.     "b", $OPT_FUNC, "CvsOpt1", $OPT_NULL,
  2011.     "d", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  2012.     "l", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  2013.     "r", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  2014.     "s", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  2015.     "w", $OPT_FUNC, "CvsOpt2", $OPT_NULL,
  2016.     );
  2017.  
  2018.  
  2019.     $recurse = 1;
  2020.     undef($cvsargs);
  2021.     &Opt_Parse(*modules, @options, $OPT_OPTIONS_FIRST | $OPT_NO_SPACE);
  2022.  
  2023.     if ($#modules < $[) {
  2024.     push(@modules, ".");
  2025.     }
  2026.     if (! -d $modules[0]) {
  2027.     $status = &Lock("r","."); 
  2028.     if ($status) {
  2029.         return $status;
  2030.     }
  2031.     $tmp = "cvs -d $cvsroot $cvsCmdArgs $command $cvsargs @modules";
  2032.     print "$tmp\n" if ($debug);
  2033.     system($tmp);
  2034.     } else {
  2035.     $status = &Lock("r", @modules); 
  2036.     if ($status) {
  2037.         return $status;
  2038.     }
  2039. module: 
  2040.     foreach $i (@modules) {
  2041.         &Chdir($i) == 0 || return 1; 
  2042.         $status = &Cvs($i, $command);
  2043.         &Chdir($pwd) == 0 || return 1; 
  2044.     }
  2045.     }
  2046.     return $status;
  2047. }
  2048.  
  2049.  
  2050.  
  2051. #
  2052. # Exit
  2053. #
  2054. # Exit with a status of 1.
  2055. #
  2056. # Results: Doesn't return
  2057. #
  2058. # Side effects: The script exits.
  2059. #
  2060.  
  2061.  
  2062. sub Exit {
  2063.     exit(1);
  2064. }
  2065.  
  2066.  
  2067. #
  2068. # Usage(@optionArray)
  2069. #
  2070. # Print out help information.
  2071. #
  2072. # Results: None
  2073. #
  2074. # Side effects: Stuff is printed
  2075. #
  2076. sub Usage {
  2077.     local(@options) = @_;
  2078.     local(%info) = (("unpack", "Create symbolic links"),
  2079.             ("checkout", "Checkout a copy of a module"),
  2080.             ("unlock", "Unlock a module"),
  2081.             ("lock", "Lock a module"),
  2082.             ("update", "Update a copy of a module"),
  2083.             ("done", "User is done with a module"),
  2084.             ("commit", "Commit changes to a module"),
  2085.             ("who", "Print a list of users with copies of a module"),
  2086.             ("diff", "Do rcsdiff on files you have changed"),
  2087.             ("status", "Print out rcs status of files"),
  2088.             ("log", "Print rcs log of files"),
  2089.             ("join", "Merge in new vendor release"),
  2090.             ("patch", "Create a patch file"),
  2091.             ("tag", "Tag a version"));
  2092.  
  2093.     &Opt_PrintUsage(@options);
  2094.     printf("\nValid commands are:\n");
  2095.     foreach $i sort ("unpack", "checkout", "unlock", "lock", "update", 
  2096.             "done", "commit", "who", "diff", "status", "log",
  2097.             @cvsCmds) {
  2098.     printf("\t$i\t%s\n", $info{$i});
  2099.     }
  2100. }
  2101.  
  2102. #
  2103. # Error($status, @args)
  2104. #
  2105. # Prints @args to STDERR, and returns $status
  2106. #
  2107. # Results: $status
  2108. #
  2109. # Side effects: Stuff is printed
  2110. #
  2111. sub Error {
  2112.     local($status) = shift;
  2113.     if ($#_ >= $[) {
  2114.     printf(STDERR @_);
  2115.     }
  2116.     return $status;
  2117. }
  2118.  
  2119. #
  2120. # ReadFile($file, $ignoreComments)
  2121. #
  2122. # Reads the contents of the given file.  If $ignoreComments is non-zero
  2123. # then any line beginning with '#' is ignored.  
  2124. #
  2125. # Results: An array containing each line of the file.  If a scalar is
  2126. #     wanted then only the first line is returned.
  2127. #
  2128. # Side effects: 
  2129. #
  2130. sub ReadFile {
  2131.     local($file) = shift;
  2132.     local($ignoreComments) = shift; 
  2133.     local(@contents);
  2134.     open(READ, "$file") ||
  2135.     return &Error(undef, "Open of $file failed: $!\n");
  2136.     if ($ignoreComments) {
  2137.     @contents = grep(!/^#/, <READ>);
  2138.     } else {
  2139.     @contents = <READ>;
  2140.     }
  2141.     close(READ);
  2142.     if ($#contents < $[) {
  2143.     return undef;
  2144.     }
  2145.     if (wantarray) {
  2146.     return @contents;
  2147.     } 
  2148.     return($contents[0]);
  2149. }
  2150.  
  2151. #
  2152. # WriteFile($file, @args)
  2153. #
  2154. # Writes @args to $file.  The file is created if it doesn't exist.
  2155. #
  2156. # Results: 0 if successful, 1 otherwise
  2157. #
  2158. # Side effects:  $file may be created, and it is written.
  2159. #
  2160. sub WriteFile {
  2161.     local($file) = shift;
  2162.     open(WRITE, ">$file") ||
  2163.     return &Error(1, "Open of $file failed: $!\n");
  2164.     print WRITE @_;
  2165.     close(WRITE);
  2166.     return 0;
  2167. }
  2168.  
  2169.  
  2170. #
  2171. # GetModuleName
  2172. #
  2173. # Gets the module name associated with a directory.
  2174. # If no directory is specified then the current working directory is used.
  2175. #
  2176. # Results: The module name.
  2177. #
  2178. # Side effects:  The cwdToModule array is filled in.
  2179. #
  2180. sub GetModuleName {
  2181.     local($dir) = shift;
  2182.     local($reposDir);
  2183.     local($index);
  2184.     local(@path);
  2185.     local($result) = undef; 
  2186.     local($found) = 0;
  2187.     local($i);
  2188.     local($owd) = $ENV{'PWD'};
  2189.     local($cwd);
  2190.     local($name);
  2191.  
  2192.     if (defined($dir)) {
  2193.     &Chdir($dir) == 0 || return undef;
  2194.     }
  2195.     $cwd = $ENV{'PWD'};
  2196.     $name = $cwdToModule{$cwd};
  2197.     if (!defined($result)) {
  2198.     if (!defined(%reposToModule)) {
  2199.         &ModMap;
  2200.     }
  2201.     $reposDir = &ReadFile("CVS.adm/Repository");
  2202.     chop($reposDir);
  2203.     printf("$reposDir\n") if ($debug);
  2204.     if (defined($reposDir)) {
  2205.         while($reposDir ne "") {
  2206.         $name = $reposToModule{$reposDir};
  2207.         if (defined($name)) {
  2208.             printf("Module $name\n") if ($debug);
  2209.             $result = $name;
  2210.             last;
  2211.         }
  2212.         $index = rindex($reposDir, '/');
  2213.         last if ($index < $[);
  2214.         $dir = substr($reposDir, 0, $index);
  2215.         }
  2216.     }
  2217.     }
  2218.     if (defined($result)) {
  2219.     $cwdToModule{$cwd} = $name;
  2220.     }
  2221.     if (defined($dir)) {
  2222.     &Chdir($owd) == 0 || return undef;
  2223.     }
  2224.     return $result;
  2225. }
  2226.  
  2227. #
  2228. # GetRootDir
  2229. #
  2230. # Given the name of a directory within a module copy returns the name
  2231. # of the root directory for that copy.  If a name is not given then
  2232. # the current directory is used.
  2233. #
  2234. # Results: The module name, undef otherwise.
  2235. #
  2236. # Side effects:  The cwdToRoot array is filled in.
  2237. #
  2238.  
  2239. sub GetRootDir {
  2240.     local($dir) = shift;
  2241.     local($owd) = $ENV{'PWD'};
  2242.     local($result) = undef;
  2243.  
  2244.     if (defined($dir)) {
  2245.     &Chdir($dir) == 0 || return undef;
  2246.     }
  2247.     $cwd = $ENV{'PWD'};
  2248.     $result = $cwdToRoot{$cwd};
  2249.     if (!defined($result)) {
  2250.  
  2251.  
  2252.  
  2253.  
  2254. #
  2255. # Chdir($dir)
  2256. #
  2257. # Changes the current working directory to $dir.  If the command fails
  2258. # an error message is printed. 
  2259. #
  2260. # Results: 0 if successful, 1 otherwise
  2261. #
  2262. # Side effects:  The current working directory is changed, and $ENV{'PWD'}
  2263. #     set to the new working directory.
  2264. #
  2265. sub Chdir {
  2266.     if (!&chdir($_[0])) {
  2267.     ($package, $file, $line) = caller;
  2268.     return &Error(1, "Chdir to %s from %s failed: $!\nFile %s Line %s", 
  2269.         $_[0], $ENV{'PWD'}, $file,$line);
  2270.     }
  2271.     return 0;
  2272. }
  2273.  
  2274. #
  2275. # ModMap
  2276. #
  2277. # Creates a mapping of module name to its subdirectory in the repository,
  2278. # and a mapping from the subdirectory to the module name.
  2279. #
  2280. # Results: 0 if successful, 1 otherwise
  2281. #
  2282. # Side effects:  The %moduleToRepos and %reposToModule are filled in.
  2283. #
  2284.  
  2285. sub ModMap {
  2286.     local($module, $dir);
  2287.     open(MOD, "cvs -d $cvsroot co -c |") ||
  2288.     return &Error(1, "Can't do \"cvs co -c\"\n");
  2289.     undef %moduleToRepos;
  2290.     while(<MOD>) {
  2291.     if (/^(\S+)\s+(\S+)/) {
  2292.         $moduleToRepos{$1} = $2;
  2293.         $reposToModule{$2} = $1;
  2294.     }
  2295.     }
  2296.     close(MOD);
  2297. }
  2298.  
  2299. #
  2300. # Main
  2301. #
  2302. #
  2303. $SIG{'INT'} = Exit;
  2304. &initpwd;
  2305. $tmpfile = "#SCVS.$$";
  2306. $status = 0;
  2307. if (&Config) {
  2308.     exit(1);
  2309. }
  2310. $command = shift;
  2311. if (!defined($command)) {
  2312.     &Usage(@options);
  2313.     exit(1);
  2314. }
  2315. printf("$command: %s\n", join(' ', @ARGV)) if ($debug);
  2316.  
  2317. if (($command eq "pack") || ($command eq "unpack")) {
  2318.     local(@options) = ("l", $OPT_FALSE, *recurse, "Recurse on subdirectories");
  2319.     &Opt_Parse(*ARGV, @options, 0);
  2320.     $status = &PackCmd($command, @ARGV);
  2321. } elsif (($command eq "checkout") || ($command eq "co")) {
  2322.     $command = "checkout";
  2323.     $status = &Checkout(@ARGV);
  2324. } elsif ($command eq "unlock") {
  2325.     $status = &UnlockCmd(@ARGV);
  2326. } elsif ($command eq "lock") {
  2327.     $status = &LockCmd(@ARGV);
  2328.     undef(@locks);
  2329. } elsif ($command eq "update") {
  2330.     $status = &UpdateCmd(1, @ARGV);
  2331. } elsif ($command eq "done") {
  2332.     $status = &DoneCmd(@ARGV);
  2333. } elsif (($command eq "commit") || ($command eq "ci")) {
  2334.     $status = &CommitCmd(@ARGV);
  2335. } elsif ($command eq "who") {
  2336.     $status = &WhoCmd(@ARGV);
  2337. } elsif ($command eq "add") {
  2338.     $status = &AddCmd(@ARGV);
  2339. } elsif ($command eq "remove") {
  2340.     $status = &RemoveCmd(@ARGV);
  2341. } elsif ($command eq "info") {
  2342.     $status = &InfoCmd(@ARGV);
  2343. } elsif ($command eq "diff") {
  2344.     $status = &DiffCmd(@ARGV);
  2345. } elsif (($command eq "status") || ($command eq "log")) {
  2346.     $status = &CvsCmd($command, @ARGV);
  2347. } elsif (grep($command eq $_, @cvsCmds)) {
  2348.     system("cvs -d $cvsroot $cvsCmdArgs $command @ARGV");
  2349.     $status = 0;
  2350. } else {
  2351.     printf("Bad command: $command\n");
  2352.     &Usage(@options);
  2353.     exit(1);
  2354. }
  2355.  
  2356. # Unlock any modules we may have locked.
  2357.  
  2358. if ($#locks >= $[) {
  2359.     &Unlock(0, @locks);
  2360. }
  2361. if ($status) {
  2362.     printf("$command failed\n");
  2363. }
  2364. exit($status);
  2365.